Abstracting connection volatility through tagged futures

International audienceThe property of connection volatility, fundamental to the ambient intelligence (AmI) domain, makes it hard to develop AmI applications. The underlying reason for this is that the code for this concern is scattered and tangled with the core functionality of the application. In this paper we introduce the abstraction mechanism for connection volatility that we have created, which allows for this concern to be implemented in a non-tangled fashion. The core of our mechanism consists in extending the existing concept of futures with meta-data, i.e. tags, to specify values to be used in an offline state. The implementation of our abstraction mechanism, in Java, is called Spoon Graffiti. The meta-data of the futures is described using annotations and the intended behavior is achieved trough source-code processing, using the Spoon annotation processor. As a result of using tagged futures and Spoon Graffiti, the specification of offline behavior of an AmI application can be performed in a non-tangled way, which significantly eases development

Expressing aspectual interactions in requirements engineering: Experiences, problems and solutions

AbstractAspect Oriented Requirements Engineering (AORE) provides support for modularizing crosscutting requirements. In the context of an industrial project in the domain of Slot Machines we needed to perform AORE, with a special emphasis on dependencies and interactions among concerns. We were however unable to find any report of large-scale industrial applications of AORE approaches that treat dependencies and interactions. We therefore evaluated two AORE approaches: Theme/Doc and MDSOCRE, to establish their applicability in our setting. In this paper we report on the limitations of both approaches we encountered and propose extensions that allow them to cope with concern interactions. We also show how these extensions provide the needed expressiveness by applying them to our industrial case study

Spec: A Framework for the Specification and Reuse of UIs and their Models

International audienceImplementing UIs is often a tedious task. To address this, UI Builders have been proposed to support the description of widgets, their location, and their logic. A missing aspect of UI Builders is however the ability to reuse and compose widget logic. In our experience, this leads to a significant amount of duplication in UI code. To address this issue, we built Spec: a UIBuilder for Pharo with a focus on reuse. With Spec, widget properties are defined declaratively and attached to specific classes known as composable classes. A composable class defines its own widget description as well as the model-widget bridge and widget interaction logic. This paper presents Spec, showing how it enables seamless reuse of widgets and how these can be customized. After presenting Spec and its implementation, we discuss how its use in Pharo 2.0 has cut in half the amount of lines of code of six of its tools, mostly through reuse. This shows that Spec meets its goals of allowing reuse and composition of widget logic.La mise en œuvre des interfaces utilisateur est souvent une tâche fastidieuse. Pour y remédier, des UI Builder ont été proposées pour soutenir la description des widgets, leur emplacement et leur logique. Un aspect manquant des UI Builder est toutefois la possibilité de réutiliser la logique et composer les widgets. D'après notre expérience, cela conduit à une quantité importante de duplication dans le code d'interfaces utilisateur. Pour résoudre ce problème, nous avons construit Spec: un UI Builder pour Pharo en mettant l'accent sur ​​la réutilisation. Avec Spec, les propriétés du widget sont définies de manière déclarative et attachées à des classes spécifiques connues sous le nom des classes composables. Une classe composable définit sa description de widget ainsi que le lien entre le modèle et le widget ainsi que la logique d'interaction avec le widget. Cet article présente Spec, en montrant comment elle permet une réutilisation transparente des widgets et comment ceux-ci peuvent être personnalisés. Après avoir présenté Spec et sa mise en œuvre, nous discutons de la façon dont son utilisation dans Pharo 2.0 a réduit de moitié la quantité de lignes de code de six de ses outils, principalement grâce à la réutilisation. Cela montre que Spec atteint ses objectifs de permettre la réutilisation et la composition de la logique des widgets

Seamless Composition and Reuse of Customizable User Interfaces with Spec

International audienceImplementing UIs is often a tedious task. To address this, UI Builders have been proposed to support the description of widgets, their location, and their logic. A missing aspect of UI Builders is however the ability to reuse and compose widget logic. In our experience, this leads to a significant amount of duplication in UI code. To address this issue, we built Spec: a UIBuilder for Pharo with a focus on reuse. With Spec, widget properties are defined declaratively and attached to specific classes known as composable classes. A composable class defines its own widget description as well as the model-widget bridge and widget interaction logic. This paper presents Spec, showing how it enables seamless reuse of widgets and how these can be customized. After presenting Spec and its implementation, we discuss how its use in Pharo 2.0 has cut in half the amount of lines of code of six of its tools, mostly through reuse. This shows that Spec meets its goals of allowing reuse and composition of widget logic

AspectMaps: A Scalable Visualization of Join Point Shadows

International audienceWhen using Aspect-Oriented Programming, it is sometimes difficult to determine at which join point an aspect executes. Similarly, when considering one join point, knowing which aspects will execute there and in what order is non- trivial. This makes it difficult to understand how the application will behave. A number of visualizations have been proposed that attempt to provide support for such program understanding. However, they neither scale up to large code bases nor scale down to understanding what happens at a single join point. In this paper, we present AspectMaps - a visualization that scales in both directions, thanks to a multi-level selective structural zoom. We show how the use of AspectMaps allows for program understanding of code with aspects, revealing both a wealth of information of what can happen at one particular join point as well as allowing to see the "big picture" on a larger code base. We demonstrate the usefulness of AspectMaps on an example and present the results of a small user study that shows that AspectMaps outperforms other aspect visualization tools

AspectMaps: Extending Moose to visualize AOP software

International audienceWhen using aspect-oriented programming the application implicitly invokes the functionality contained in the aspects. Consequently program comprehension of such a software is more intricate. To alleviate this difficulty we developed the AspectMaps visualization and tool. AspectMaps extends the Moose program comprehension and reverse engineering platform with support for aspects, and is implemented using facilities provided by Moose. In this paper we present the AspectMaps tool, and show how it can be used by performing an exploration of a fairly large aspect-oriented application. We then show how we extended the FAMIX meta-model family that underpins Moose to also provide support for aspects. This extension is called ASPIX, and thanks to this enhancement Moose can now also treat aspect-oriented software. Finally, we report on our experiences using some of the tools in Moose; Mondrian to implement the visualization, and Glamour to build the user interface. We discuss how we were able to implement a sizable visualization tool using them and how we were able to deal with some of their limitations. Note: This paper uses colors extensively. Please use a color version to better understand the ideas presented here

PLOMO Associate Team Final Report

The goal of Plomo is to develop new meta tools to improve and bring synergy in the existing infrastructure of Pharo1 (for software development) and the Moose software analysis platform2 (for maintenance). PLOMO will (i) enhance the Opal open compiler infrastructure to support plugin definition, (ii) offer an infrastructure for change and event tracking as well as models to compose and manipulate them, (iii) work on a layered library of algorithms for the Mondrian visualization engine of Moose, (iv) work on new ways of profiling applications. All the efforts will be performed on Pharo and Moose, two platforms heavily used by the RMoD and Pleiad teams

The Spec UI framework

International audienc

Context Distribution for Supporting Composition of Applications in Ubiquitous Computing

Poster PaperInternational audienceFor context-aware devices and applications to be able to interact both with each other and their environment, mechanisms are required to allow these to react to changes in the environment. Furthermore, individual applications participating in a context must work together in an integrated and coherent manner. To address this concern, we have designed and implemented CARBO, a generative, rule based centralized orchestration engine. However, in ubiquitous computing, context is distributed amongst different participants. In this paper we describe how we extended CARBO with the notion of context slices, which distribute the context state amongst different devices. We also discuss the use of tagged futures as an implementation strategy. This simplifies the work needed to synchronize context instances across devices, which eases the maintenance of context consistency